import time
import dashscope
from http import HTTPStatus
from openai import OpenAI

from pathlib import Path
import sys
from requests.exceptions import Timeout, RequestException
import re
import json
import pandas as pd
from openai import OpenAI
import concurrent.futures
import random
tyqw_api_list = ["sk-b83b7153***cb87effcd8476470b5",
                 "sk-a69b3a5***a6464eb0f53275dbb5dad6",
                 "sk-c87b1b81***989a189627b5b1d2"]


def green_industry_rule(rs):
    '''
    绿色行业策略

    '''
    print('开始施加纯绿行业策略')
    green_industry = pd.read_excel('./llmFile/green_industry.xlsx')
    indu = rs.industry_china.values[0]
    flag = (rs.class_top1.values[0] == '非绿') & (indu in green_industry.industry.to_list())

    if flag:
        rs.class_top1 = green_industry.loc[green_industry.industry == indu,'y'].values[0]
        rs.Reason = green_industry.loc[green_industry.industry == indu,'reason'].values[0]
    print('施加完毕')
    return rs
def RecommendLLM(rs):
    print('开始推荐',file=sys.stderr)
    dft = pd.read_excel('./llmFile/行业限定策略表.xlsx', sheet_name='四级行业推荐')

    js = rs.to_dict(orient='records')[0]

    if js['industry_china'] is None:
        js['industry_china'] = ''

    js['Recommend'] = dft.loc[dft.industry == js['industry_china'], 'y'].to_list()
    if js['class_top1'] in js['Recommend']:
        js['Recommend'].remove(js['class_top1'])

    if js['class_top2'] in js['Recommend']:
        js['Recommend'].remove(js['class_top2'])

    if js['class_top3'] in js['Recommend']:
        js['Recommend'].remove(js['class_top3'])

    rs = pd.DataFrame([js])
    print('推荐结束',file=sys.stderr)
    return rs
def GetOneResult(js,num=3):

    import time
    start = time.time()

    tyqw_api_key = random.choice(tyqw_api_list)
    loan_type = js['projectType']
    # import random
    # js['projectId'] = random.randint(1,100000) + random.randint(100,10000)
    pdf_content = load_pdf(file_path='./llmFile/绿色金融支持项目目录.xlsx')
    print('开始进行大模型识别\n\n',file=sys.stderr)
    js_response = get_chat_response(js,pdf_content, num,retries=3, delay=2,tyqw_api_key=tyqw_api_key)
    if js_response == {"error": "No JSON format in response after retries"}:
        js_response = {
           "是否绿色": "否",
           "标准与理由":[{"参考标准":"无","理由说明":"该项目不符合认绿标准，因此属于非绿，建议增加更多有效信息稍后重新认定"}]}
    print(js_response)
    print('大模型识别结束\n\n',file=sys.stderr)
    rs = clean_resolver_filter(js, js_response, num=num)
    if js['projectType'] == 'NonProjectLoan':
        rs = green_industry_rule(rs)
    # rs.to_excel('rs.xlsx')
    rs = RecommendLLM(rs)
    rs = map_other_result(rs, loan_type)
    end = time.time()
    print('所用时间',end-start)
    rs.standardType = rs.standardType.str.replace('lzz','lsjr')
    return rs

# rs = GetOneResult(js)
# print(rs)

def GetLLMresult2(js_arr):

    if str(js_arr)[0] == '{':
        js_arr = [js_arr]
    dft = pd.DataFrame()
    for js in js_arr:
        rs = GetOneResult(js)
        dft = pd.concat([dft,rs])

    return dft




def fetch_data(js):
    # 假设GetLLMresult是一个同步函数，用于发送网络请求并返回结果
    return GetOneResult(js)

def GetLLMresult(js_arr):
    import concurrent.futures
    lst = []
    # final = pd.DataFrame()
    if str(js_arr)[0] == '{':
        js_arr = [js_arr]
    # dft_default = pd.read_excel('./llmFile/default.xlsx')
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        # 使用线程池并发地执行fetch_data函数
        futures = [executor.submit(fetch_data, js) for js in js_arr]
        for future in concurrent.futures.as_completed(futures):
            try:
                # 获取每个线程的返回结果
                dft = future.result()
                lst.append(dft)
            except Exception as e:
                print(f"线程出错: {e}")
                # lst.append(dft_default)

    # 将所有结果合并成一个DataFrame
    print(lst,'--------------------------------')
    final = pd.concat(lst)

    # final.to_excel('./final.xlsx')
    if 'industry_china' in final.columns:
        del final['industry_china']
    final = final.rename(columns = {'class_top1':'classTop1','class_top2':'classTop2','class_top3':'classTop3','Reason':'reason'})
    if 'newText' in final.columns:
        del final['newText']
    return final

def clean_resolver_filter(js, js_response, num=3):
    '''
    输入：基础信息+模型返回结果
    输出： 清洗后经过行业筛选得结果

    '''
    # print(js_response)
    print('开始对大模型结果进行数据清洗',file=sys.stderr)
    js_response = map_fax(js_response)  # 映射清洗
    print('数据清洗完毕\n\n',file=sys.stderr)
    # print(js_response)

    print('开始将json数据解析成dataframe',file=sys.stderr)
    rs, flag = resolver(js, js_response, num=num)
    # print(rs)
    print('解析完毕\n\n',file=sys.stderr)
    if '行业筛选' == '行业筛选':
        if not flag:
            print('开始施加行业筛选策略\n\n',file=sys.stderr)
            rs = industry_choice(rs)
    else:
        ls= [ col for col in rs.columns if 'reason' in col]

        for col in ls:
            del rs[col]

    # 统一输出个数
    print('统一输出个数',file=sys.stderr)
    lst1 = ['class_top' + str(col + 1) for col in range(num)]
    lst2 = [col for col in rs.columns if 'class_top' in col]
    for col in [col for col in lst1 if col not in lst2]:
        rs[col] = '非绿'
    print('统一完毕',file=sys.stderr)
    print(rs)
    return rs


def map_fax(js_response,file_name='./llmFile/class_lzz.xlsx'):
    import re
    dic_map = pd.read_excel(file_name)

    dic_map_code = dic_map.set_index('y_code').y
    dic_map_txt = dic_map.set_index('y_txt').y

    tmp_dic = js_response['标准与理由']
    for dic in tmp_dic:
        txt = re.search(r'[^0-9\.\s]+',dic['参考标准']).group()
        # print(txt)
        dic['参考标准'] = dic_map_txt.get(txt,dic['参考标准'])

    js_response['标准与理由'] = tmp_dic
    return js_response

def resolver(js,js_response,num=3):

    """
    输入 js：贷款用途
        js_response:大模型将返回结果
    输出：
        单条dataframe 包含class_top reason

    """
    dic2 = {}
    dic2['projectId'] = js['projectId']
    dic2['industry_china'] = js['industryName']
    Reason = ''
    flag = False
    if js_response['是否绿色'] == '否':
        flag = True
        for i in range(num):
            class_top = 'class_top' + str(i + 1)
            dic2[class_top] = '非绿'
        Reason = Reason + js_response['标准与理由'][0]['理由说明']
    else:
        for i,dic in enumerate (js_response['标准与理由']):

            class_top = 'class_top' + str(i+1)
            reason = 'reason' + str(i+1)
            dic2[class_top] = dic['参考标准']
            dic2[reason] = dic['理由说明']
            Reason += dic['理由说明']

    dic2['Reason'] = Reason
    d = pd.DataFrame([dic2])
    d.industry_china = d.industry_china.fillna('')
    d['newText'] = '暂无'
    return d,flag


def industry_choice(rs):

    '''
    输入：大模型输出的结果 dataframe


    '''
    # import os
    # os.chdir(r'D:\workdoc\工作文件20240711\绿色识别202407\南京银行绿色识别\20250217新标准文档解析')

    indu_dic = pd.read_excel('./llmFile/行业限定策略表.xlsx')

    indu_dic = indu_dic.groupby('y').industry.apply(lambda x: ','.join(x)).to_dict()

    # 如果flag为false不需要行业筛选 直接跳过 1行业对比判断，true的筛选留存 2 重新组合识别理由 重新排序列名

    temp_dic = rs.to_dict(orient='records')[0]
    collect = []
    collect2 = []

    #开始筛选
    for k, v in temp_dic.items():
        if 'class_top' in k:
            limit_indu = indu_dic.get(v, None)
            # print(limit_indu)
            if limit_indu is None:
                collect.append(k)
                if '10' in k:
                    collect2.append('reason' + k[-2:])
                else:
                    collect2.append('reason' + k[-1])
            elif temp_dic['industry_china'] in limit_indu:
                collect.append(k)
                if '10' in k:
                    collect2.append('reason' + k[-2:])
                else:
                    collect2.append('reason' + k[-1])
            else:
                continue
    #根据筛选表剔除其余的
    if len(collect) > 0:

        columns = [col for col in rs.columns if 'reason' not in col and 'class_top' not in col]
        columns.extend(collect)
        columns.extend(collect2)
        rs['Reason'] = ''

        for col in collect2:
            rs['Reason'] += rs[col]

        rs = rs[columns]
        for i, col in enumerate(collect):
            rs = rs.rename(columns={col: 'class_top' + str(i + 1)})
        for i, col in enumerate(collect2):
            rs = rs.rename(columns={col: 'reason' + str(i + 1)})


    else:
        rs['Reason'] = '该项目项目内容不在《绿色金融支持项目目录》规定范围内，因此属于非绿色贷款'
        for col in [col for col in rs.columns.to_list() if 'class_top' in col]:
            rs[col] = '非绿'

    for col in [col for col in rs.columns if 'reason' in col]:
        del rs[col]
    return rs
def prompt_text2(text,pdf_content,num):
    loan_type = text['projectType']
    if loan_type == 'ProjectLoan':
        text = '投向行业：' + str(text['industryName']) + '项目内容： ' +  str(text['projectName']) + ':' + str(text['loanPurpose'])
    else:
        text = '投向行业：' + str(text['industryName'])  +  '贷款用途: ' + str(text['loanPurpose'])
    prompt_str = f"""
       请按照以下步骤分析项目内容，严格按照输出格式要求生成结果：
        **分析步骤：**
        1. **合规判断**：基于《绿色金融支持项目目录》（内容：{pdf_content}）判断项目（内容：{text}）是否符合绿色标准。
           - 如果项目符合绿色标准，请继续第2、3步。
           - 如果项目不符合绿色标准，请跳转到第4步，提供否决说明理由。
        2. **条款匹配**：若项目符合绿色标准，找出最相关的前{num}个三级目录条款（格式：X.X.X），按关联度降序排列。
        3. **理由阐述**：对每个匹配条款提供不超过50字的精准说明，解释项目内容与标准条款之间的关系，为什么项目符合该条款的要求。
        4. **否决说明**：如果项目不符合绿色标准，说明不符合的原因，并引用具体排除条款（例如：某些行业限制、环境影响等）。

        **输出要求：**
        1. 输出的JSON字段必须严格按照以下格式：
        2. "是否绿色"：根据合规判断结果填写“是”或“否”。
        3. "识别结果"：一个数组，最多包含{num}条匹配结果。如果项目符合绿色标准，包含前{num}个相关的条款；如果不符合绿色标准，包含一条说明项目不符合绿色产业目录的条款。

          **格式要求：**
        - "参考标准"：必须使用三级目录编号（如1.1.18），禁止使用二级目录。
        - 如果项目不符合绿色标准，请在"识别结果"中包含一条“参考标准”为“无”的项，标明该项目不符合绿色产业目录的原因。
        - 每个理由说明必须详细解释项目内容与标准条款的映射关系，必须包括项目内容中的关键词。

        **输出示例：**
        **判断项目符合绿色标准的输出：**

       {{
           "是否绿色": "是",
           "标准与理由":[{{"参考标准":"1.1.18 绿色建筑材料制造",
                      "理由说明":"该项目涉及可再生绿化沥青混凝土的生产和制造，符合绿色产业指导目录中绿色建筑材料制造（1.1.18）的要求。" }},
                      {{"参考标准":"4.2.2 太阳能利用设施建设和运营",
                      "理由说明":"项目中的配套环保设备可能涉及太阳能利用设施（4.2.2）以及装配式建筑设计"}},
                      {{"参考标准":"6.1.6 装配式建筑设计和建造",
                      "理由说明":"项目中的配套环保设备可能涉及建造（6.1.6）等绿色技术或设施的应用，进一步体现了绿色发展的理念。"}},
                      ]

       }}
        **判断项目不符合绿色标准的输出：**
       {{
           "是否绿色": "否",
           "标准与理由":[{{"参考标准":"无",
                     "理由说明":"该项目不符合绿色产业目录的条款，原因是未涉及可持续生产或绿色技术。"
                      ]
       }}

       **错误示例**（避免出现）
        {{
            "标准与理由": [
                {{
                    "参考标准": "绿色建筑",  // 错误：未使用三级编号
                    "理由说明": "符合环保要求"  // 错误：未说明具体关联
                }}
            ]
        }}
    1. 确保“是否绿色”字段准确反映项目合规情况。
    2. 每个"理由说明"必须精准、简洁，避免泛泛而谈。
    3. 如果项目不符合绿色标准，必须在“识别结果”中详细解释排除的理由和条款。
       """
    return prompt_str


def prompt_text3(text, pdf_content, num): #增加纯绿行业策略
    loan_type = text['projectType']
    if loan_type == 'ProjectLoan':
        text = '投向行业：' + str(text['industryName']) + '项目内容： ' + str(text['projectName']) + ':' + str(
            text['loanPurpose'])
    else:
        text = '投向行业：' + str(text['industryName']) + '贷款用途: ' + str(text['loanPurpose'])
    indu_rule = pd.read_excel('./llmFile/green_industry.xlsx').set_index('industry').y.to_dict()
    if loan_type == 'NonProjectLoan':
        indu_prompt = '''5. **特定的绿色行业策略规则**: 如果项目内容的投向行业符合以下范围则定义为绿色行业且符合绿色标准，此时忽略项目内容和贷款用途，直接根据行业输出对应目录 。绿色行业与三级条款对应关系如下：''' + str(
            indu_rule)
    else:
        indu_prompt = ''
    prompt_str = f"""
       请按照以下步骤分析项目内容，严格按照输出格式要求生成结果：
        **分析步骤：**
        1. **合规判断**：基于《绿色金融支持项目目录》（内容：{pdf_content}）判断项目（内容：{text}）是否符合绿色标准。
           - 如果项目符合绿色标准，请继续第2、3步。
           - 如果项目不符合绿色标准，请跳转到第4步，提供否决说明理由。
        2. **条款匹配**：若项目符合绿色标准，找出最相关的前{num}个三级目录条款（格式：X.X.X），按关联度降序排列。
        3. **理由阐述**：对每个匹配条款提供不超过50字的精准说明，解释项目内容与标准条款之间的关系，为什么项目符合该条款的要求。
        4. **否决说明**：如果项目不符合绿色标准，说明不符合的原因，并引用具体排除条款（例如：某些行业限制、环境影响等）。
        {indu_prompt}
        **输出要求：**
        1. 输出的JSON字段必须严格按照以下格式：
        2. "是否绿色"：根据合规判断结果填写“是”或“否”。
        3. "识别结果"：一个数组，最多包含{num}条匹配结果。如果项目符合绿色标准，包含前{num}个相关的条款；如果不符合绿色标准，包含一条说明项目不符合绿色产业目录的条款。

          **格式要求：**
        - "参考标准"：必须使用三级目录编号（如1.1.18），禁止使用二级目录。
        - 如果项目不符合绿色标准，请在"识别结果"中包含一条“参考标准”为“无”的项，标明该项目不符合绿色产业目录的原因。
        - 每个理由说明必须详细解释项目内容与标准条款的映射关系，必须包括项目内容中的关键词。

        **输出示例：**
        **判断项目符合绿色标准的输出：**

       {{
           "是否绿色": "是",
           "标准与理由":[{{"参考标准":"1.1.18 绿色建筑材料制造",
                      "理由说明":"该项目涉及可再生绿化沥青混凝土的生产和制造，符合绿色产业指导目录中绿色建筑材料制造（1.1.18）的要求。" }},
                      {{"参考标准":"4.2.2 太阳能利用设施建设和运营",
                      "理由说明":"项目中的配套环保设备可能涉及太阳能利用设施（4.2.2）以及装配式建筑设计"}},
                      {{"参考标准":"6.1.6 装配式建筑设计和建造",
                      "理由说明":"项目中的配套环保设备可能涉及建造（6.1.6）等绿色技术或设施的应用，进一步体现了绿色发展的理念。"}},
                      ]

       }}
        **判断项目不符合绿色标准的输出：**
       {{
           "是否绿色": "否",
           "标准与理由":[{{"参考标准":"无",
                     "理由说明":"该项目不符合绿色产业目录的条款，原因是未涉及可持续生产或绿色技术。"
                      ]
       }}

       **错误示例**（避免出现）
        {{
            "标准与理由": [
                {{
                    "参考标准": "绿色建筑",  // 错误：未使用三级编号
                    "理由说明": "符合环保要求"  // 错误：未说明具体关联
                }}
            ]
        }}
    1. 确保“是否绿色”字段准确反映项目合规情况。
    2. 每个"理由说明"必须精准、简洁，避免泛泛而谈。
    3. 如果项目不符合绿色标准，必须在“识别结果”中详细解释排除的理由和条款。
       """
    return prompt_str
def get_chat_response(content,pdf_content, num=3,retries=3, delay=2,tyqw_api_key="sk-b83b7153ecc945cb87effcd8476470b5"):
    # 创建API客户端
    client = OpenAI(
        api_key=tyqw_api_key,
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    )
    prompt = prompt_text2(content,pdf_content,num)
    # print(prompt)
    # 尝试多次调用API
    for attempt in range(retries):
        try:
            # 调用API获取响应
            completion = client.chat.completions.create(
                model="qwen-plus",  # 模型名称
                messages=[{'role': 'system', 'content': 'You are a helpful assistant.'},
                          {'role': 'user', 'content': prompt}]
            )
            result = completion.choices[0].message.content
            # 检查是否包含JSON格式
            if result.startswith("```json"):
                json_match = re.search(r'```json(.*?)```', result, re.DOTALL)
                if json_match:  # 如果匹配成功
                    result = json_match.group(1).strip()
                    try:
                        result_json = json.loads(result)  # 将字符串转为 JSON 格式
                        return result_json  # 返回JSON格式的结果
                    except json.JSONDecodeError as json_error:
                        print(f"JSON parsing error: {json_error}")
                        raise  # 如果JSON解析失败，则抛出异常，外部可以捕获
                else:
                    print(f"No JSON content found in the response (Attempt {attempt + 1})")
                    if attempt < retries - 1:
                        time.sleep(delay)
                        continue  # 如果没有找到JSON格式，继续重试

            else:
                # 如果返回的不是JSON格式，重新调用API
                print(f"Unexpected response format, retrying... (Attempt {attempt + 1})")
                if attempt < retries - 1:
                    time.sleep(delay)
                    continue  # 如果不是JSON格式，继续重试
                else:
                    return {"error": "No JSON format in response after retries"}

        except Exception as e:
            # 如果出现错误，打印错误信息，并在下一次尝试之前等待一段时间
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt < retries - 1:
                time.sleep(delay)
            else:
                # 如果重试次数达到限制，抛出异常或返回错误信息
                return {"error": str(e)}

    return {"error": "Failed after multiple attempts"}


def load_pdf(file_path='./llmFile/绿色金融支持项目目录.xlsx',file_name='《绿色金融支持项目目录》'):
    print('读取结构化数据', file=sys.stderr)
    dic = {}
    df = pd.read_excel(file_path)[['y', 'text']]
    content = df.set_index('y').text.to_dict()
    dic[file_name] = content
    pdf_content = str(dic)
    print('读取完毕\n\n', file=sys.stderr)
    return pdf_content


def get_data(js):
    if str(js)[0] == '[':
        data = pd.DataFrame(js)
    elif str(js)[0] == '{':
        data = pd.DataFrame([js])
    return data


def save(df):
    import pandas as pd
    from openpyxl import load_workbook

    # 创建示例DataFrame
    # data = {'Name': ['Alice', 'Bob', 'Charlie'],
    #         'Age': [25, 30, 35],
    #         'City': ['New York', 'Los Angeles', 'Chicago']}
    # df = pd.DataFrame(data)

    # Excel文件路径
    file_path = 'result_ty.xlsx'

    # 尝试加载现有Excel文件，如果文件不存在则创建一个新的工作簿
    try:
        book = load_workbook(file_path)
    except FileNotFoundError:
        book = pd.ExcelWriter(file_path, engine='openpyxl').book

    # 获取工作表，如果工作表不存在则创建
    sheet_name = 'Sheet1'
    if sheet_name in book.sheetnames:
        writer = pd.ExcelWriter(file_path, engine='openpyxl')
        writer.book = book
        writer.sheets = {ws.title: ws for ws in book.worksheets}

        # 获取现有数据的最后一行行号
        max_row = writer.sheets[sheet_name].max_row

        # 将新数据写入到现有数据的下一行
        df.to_excel(writer, sheet_name=sheet_name, startrow=max_row, index=False, header=False)
        writer.save()
    else:
        # 如果工作表不存在，直接写入数据并创建工作表
        df.to_excel(file_path, sheet_name=sheet_name, index=False)
    return df


def project_goods_rule_llm(data, origins, path=r'./THUCNews/data/'):
    print('开始施加生产资料策略',file=sys.stderr)
    rule = pd.read_excel(path + 'product_goods_rule.xlsx')
    origins = origins.drop_duplicates()
    origins = origins.rename(columns={'industryName':'industry_china','secondOption':'level2'})
    if 'level2' not in origins.columns:
        origins['level2'] = ''
    temp = pd.merge(origins, rule, on=['industry_china', 'level2'], how='left')

    temp2 = temp[['projectId', 'lrz', 'ld', 'lz', 'ld24', 'gt', 'tjp']].set_index('projectId').stack(
        dropna=False).reset_index()
    temp2.columns = ['projectId', 'standardType', 'rule_result']

    data2 = pd.merge(data, temp2, on=['projectId', 'standardType'], how='left')

    data2.loc[~data2.rule_result.isna(), 'class_top2'] = '非绿'
    data2.loc[~data2.rule_result.isna(), 'class_top1'] = pd.NA
    data2.class_top1 = data2.class_top1.fillna(data2.rule_result)

    data2.loc[data2.class_top1 == 'D1.1利用太阳能光伏技术发电','class_top2'] = 'D1.2使用聚光太阳能(CSP)技术发电'
    del data2['rule_result']
    print('生产资料策略施加完毕',file=sys.stderr)

    return data2
#


def map_other_result(df, loan_type):
    '''
    输入24年结果df,贷款类型 loan_type

    输出增加标准后的result
    '''
    # 目录映射
    print('开始其他标准映射', file=sys.stderr)
    stand_map = pd.read_excel(r'./llmFile/绿色产业目录映射关系表.xlsx').drop_duplicates('lzz').dropna(subset=['lzz'])

    if 'Recommend' in df.columns:

        df_recommend = df[['projectId','Recommend']]
        del df['Recommend']
    df = df.set_index(['projectId','industry_china','Reason','newText'])

    dic_d = {}
    for std in ['ld24', 'lz', 'lrz', 'tjp', 'gt']:
        dic_d[std] = df.copy().applymap(lambda x: stand_map.set_index('lzz')[std].to_dict().get(x, pd.NA)).fillna(
            '非绿')
    # df1 = save(df)
    # 调整位置
    # print('调整映射结果的排放位置', file=sys.stderr)
    # for k, temp_df in dic_d.items():
    #     cond1 = (temp_df.class_top1 == '非绿') & (temp_df.class_top2 != '非绿')
    #     cond2 = (temp_df.class_top1 == '非绿') & (temp_df.class_top3 != '非绿')
    #     # cond3 = (temp_df.class_top1 == '非绿') & (temp_df.class_top4 != '非绿')
    #
    #     temp_df.loc[cond1, 'class_top1'] = temp_df.class_top2
    #     temp_df.loc[cond2, 'class_top1'] = temp_df.class_top3
    #     # temp_df.loc[cond3,'class_top1'] = temp_df.class_top4
    #
    #     temp_df.loc[cond1, 'class_top2'] = '非绿'
    #     temp_df.loc[cond2, 'class_top3'] = '非绿'

    # temp_df.loc[cond3,'class_top4'] = '非绿'

    # 增加字段
    final_lst = []
    final_lst.append(df)
    df['standardType'] = 'lzz'

    for k, dft in dic_d.items():
        dft['standardType'] = k
        final_lst.append(dft)

    result = pd.concat(final_lst)
    result['projectType'] = loan_type
    result = result.reset_index()

    # 非绿统一化
    # print('非绿统一化',file=sys.stderr)
    # for id in result.projectId.unique():
    #     if result.loc[(result.projectId == id) & (result.standardType == 'ld24'), 'class_top1'].values[0] == '非绿':
    #         result.loc[result.projectId == id, 'class_top1'] = '非绿'
    print('映射结束\n\n', file=sys.stderr)
    result.loc[~(result.standardType == 'lzz'), 'Reason'] = '此标准非人行最新标准，暂无解释结果'
    result.loc[~(result.standardType == 'lzz'), 'newText'] = '暂无'
    result = pd.merge(result,df_recommend,on='projectId')
    # result.to_excel('./结果展示.xlsx')
    # result = pd.merge(result,df.reset_index()[['projectId','standardType','Reason','newText']],on=['projectId','standardType'],how='left')
    return result
